/**
 * @content 线图形信息功能组件
 * @author  2019-09-12
 */
import { NativeModules } from 'react-native';

let RI = NativeModules.JSRegInfo;

import GeomInfo from './GeomInfo.js';

/**
 * @class RegInfo
 */
export default class RegInfo extends GeomInfo {
  constructor() {
    super();
    Object.defineProperty(this, '_MGRegInfoId', {
      get: function() {
        return this._MGGeomInfoId;
      },
      set: function(_MGRegInfoId) {
        this._MGGeomInfoId = _MGRegInfoId;
      },
    });
  }

  /**
   * 构造一个新的 RegInfo 对象
   * @memberOf RegInfo
   * @return {Promise<RegInfo>}
   */
  async createObj() {
    try {
      var { RegInfoId } = await RI.createObj();
      var regInfo = new RegInfo();
      regInfo._MGRegInfoId = RegInfoId;
      return regInfo;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 构造一个新的 RegInfo 对象
   * @memberOf RegInfo
   * @param ang 图案角度
	 * @param endClr 结束填充色
	 * @param fillClr 区域填充色
	 * @param fillMode 填充模式
	 * @param fullPatFlg 是否需要完整图案填充
	 * @param libId 库编号
	 * @param outPenW 图案笔宽
	 * @param ovprnt 覆盖方式
	 * @param patCls 图案颜色
	 * @param patId 符号编号
	 * @param patHeight 图案高
	 * @param patWidth 图案宽
   * @return {Promise<RegInfo>}
   */
  async createObjByParam(ang, endClr, fillClr, fillMode, fullPatFlg, libId, outPenW, ovprnt, patCls, patId,
    patHeight, patWidth) {
    try {
      var { RegInfoId } = await RI.createObjByParam(ang, endClr, fillClr, fillMode, fullPatFlg, libId, outPenW, ovprnt, patCls, patId,
        patHeight, patWidth);
      var regInfo = new RegInfo();
      regInfo._MGRegInfoId = RegInfoId;
      return regInfo;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取库编号
   * @memberOf RegInfo
   * @return {Promise}库编号
   */
  async getLibID() {
    try {
      return await RI.getLibID(this._MGRegInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置库编号
   * @memberOf RegInfo
   * @param newVal 库编号
   * @return {Promise<void>}
   */
  async setLibID(newVal) {
    try {
      await RI.setLibID(this._MGRegInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取覆盖方式
   * @memberOf RegInfo
   * @return {Promise}覆盖方式
   */
  async getOvprnt() {
    try {
      return await RI.getOvprnt(this._MGRegInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取符号编号
   * @memberOf RegInfo
   * @return {Promise}符号编号
   */
  async getPatID() {
    try {
      return await RI.getPatID(this._MGRegInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置符号编号
   * @memberOf RegInfo
   * @param newVal 符号编号
   * @return {Promise<void>}
   */
  async setPatID(newVal) {
    try {
      await RI.setPatID(this._MGRegInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取填充模式
   * @memberOf RegInfo
   * @return {Promise}填充模式
   */
  async getFillMode() {
    try {
      return await RI.getFillMode(this._MGRegInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置填充模式
   * @memberOf RegInfo
   * @param newVal 填充模式
   * @return {Promise<void>}
   */
  async setFillMode(newVal) {
    try {
      await RI.setFillMode(this._MGRegInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取区域填充色
   * @memberOf RegInfo
   * @return {Promise<Number>}区域填充色
   */
  async getFillClr() {
    try {
      let fillClr = await RI.getFillClr(this._MGRegInfoId);
      return fillClr;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置区域填充色
   * @memberOf RegInfo
   * @param {Number} color 区域填充色
   * @return {Promise<void>}
   */
  async setFillClr(color) {
    try {
      await RI.setFillClr(this._MGRegInfoId, color);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取结束填充色
   * @memberOf RegInfo
   * @return {Promise<Number>}结束填充色
   */
  async getEndClr() {
    try {
      let color = await RI.getEndClr(this._MGRegInfoId);
      return color;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置结束填充色
   * @memberOf RegInfo
   * @param {Number} color 结束填充色
   * @return {Promise<void>}
   */
  async setEndClr(color) {
    try {
      await RI.setEndClr(this._MGRegInfoId, color);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取图案高
   * @memberOf RegInfo
   * @return {Promise}图案高
   */
  async getPatHeight() {
    try {
      return await RI.getPatHeight(this._MGRegInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置图案高
   * @memberOf RegInfo
   * @param newVal 图案高
   * @return {Promise<void>}
   */
  async setPatHeight(newVal) {
    try {
      await RI.setPatHeight(this._MGRegInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取图案宽
   * @memberOf RegInfo
   * @return {Promise}图案宽
   */
  async getPatWidth() {
    try {
      return await RI.getPatWidth(this._MGRegInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置图案宽
   * @memberOf RegInfo
   * @param newVal 图案宽
   * @return {Promise<void>}
   */
  async setPatWidth(newVal) {
    try {
      await RI.setPatWidth(this._MGRegInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取图案角度
   * @memberOf RegInfo
   * @return {Promise}图案角度
   */
  async getAngle() {
    try {
      return await RI.getAngle(this._MGRegInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置图案角度
   * @memberOf RegInfo
   * @param newVal 图案角度
   * @return {Promise<void>}
   */
  async setAngle(newVal) {
    try {
      await RI.setAngle(this._MGRegInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取图案颜色
   * @memberOf RegInfo
   * @return {Promise<Number>}图案颜色
   */
  async getPatClr() {
    try {
      let color = await RI.getPatClr(this._MGRegInfoId);
      return color;
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置图案颜色
   * @memberOf RegInfo
   * @param {Number} color 图案颜色
   * @return {Promise<void>}
   */
  async setPatClr(color) {
    try {
      await RI.setPatClr(this._MGRegInfoId, color);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取图案笔宽
   * @memberOf RegInfo
   * @return {Promise}图案笔宽
   */
  async getOutPenW() {
    try {
      return await RI.getOutPenW(this._MGRegInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置图案笔宽
   * @memberOf RegInfo
   * @param newVal 图案笔宽
   * @returns {Promise<void>}
   */
  async setOutPenW(newVal) {
    try {
      await RI.setOutPenW(this._MGRegInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 获取是否需要完整图案填充
   * @memberOf RegInfo
   * @return {Promise}是否需要完整图案填充
   */
  async getFullPatFlg() {
    try {
      return await RI.getFullPatFlg(this._MGRegInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置是否需要完整图案填充
   * @memberOf RegInfo
   * @param newVal 是否需要完整图案填充
   * @returns {Promise<void>}
   */
  async setFullPatFlg(newVal) {
    try {
      await RI.setFullPatFlg(this._MGRegInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设获取几何类型
   * @memberOf RegInfo
   * @return {Promise} 几何类型
   */
  async getGeomType() {
    try {
      return await RI.getGeomType(this._MGRegInfoId);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 设置是否需要完整图案填充
   * @memberOf RegInfo
   * @param newVal 是否需要完整图案填充
   * @return {Promise<void>}
   */
  async setOvprnt(newVal) {
    try {
      await RI.setOvprnt(this._MGRegInfoId, newVal);
    } catch (e) {
      console.error(e);
    }
  }

  /**
   * 克隆几何图形信息
   * @memberOf RegInfo
   * @return {Promise<GeomInfo>} 几何图形信息
   */
  async Clone() {
    try {
      let { GeomInfoId } = await RI.Clone(this._MGPntInfoId);
      var geomInfo = new GeomInfo();
      geomInfo._MGGeomInfoId = GeomInfoId;
      return geomInfo;
    } catch (e) {
      console.error(e);
    }
  }
}
